home *** CD-ROM | disk | FTP | other *** search
/ Chip: Internet / Chip Internet.iso / wwwutil / hotjava.ins / hotjava.exe / hotjava / classsrc / browser / ImageHandle.java < prev    next >
Text File  |  1995-08-11  |  6KB  |  271 lines
  1. /*
  2.  * @(#)ImageHandle.java    1.23 95/05/21 Chris Warth
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19. package browser;
  20.  
  21. import awt.*;
  22. import net.www.html.*;
  23. import java.io.InputStream;
  24.  
  25. class ImageRef extends Ref {
  26.     public Object reconstitute() {
  27.     return null;
  28.     }
  29. }
  30.  
  31. public class ImageHandle extends Observable implements Observer {
  32.     ImageRef    image;
  33.     URL url;    
  34.     Window win;
  35.     protected boolean fetching = false;
  36.     DIBitmap    bm;
  37.  
  38.     ImageHandle(Window win, URL url) {
  39.     image = new ImageRef();
  40.     this.win = win;
  41.     this.url = url;
  42.     }
  43.  
  44.     public URL getURL() {
  45.     return url;
  46.     }
  47.  
  48.     // This methid is unsafe. It should be synchronized but it isn't
  49.     public Object getImage(Observer o, boolean waitForIt) {
  50.     Object    img = image.check();
  51.  
  52.     if (img == null) {
  53.         if (o != null) {
  54.         addObserver(o);
  55.         }
  56.         ImageCache.fetch(this);
  57.         if (waitForIt) {
  58.         waitForImage();
  59.         }
  60.         img = image.check();
  61.     }
  62.     return img;
  63.     }
  64.  
  65.     public void setImage(Object img) {
  66.     fetching = false;
  67.     image.setThing(img);
  68.     setChanged();
  69.     synchronize (this) {
  70.         notifyAll();    /* notify people doing waitForImage() */
  71.     }
  72.     notifyObservers();
  73.     }
  74.  
  75.     public Object checkForImage(Observer o) {
  76.     if (o != null) {
  77.         addObserver(o);
  78.     }
  79.     return image.check();
  80.     }
  81.  
  82.     public synchronized void waitForImage() {
  83.     while (image.check() == null) {
  84.         wait();
  85.     }
  86.     }
  87.  
  88.     public synchronized void waitForSize() {
  89.     while ((bm == null) && (image.check() == null)) {
  90.         wait();
  91.     }
  92.     }
  93.  
  94.     public int width() {
  95.     if (bm != null) {
  96.         return bm.width;
  97.     }
  98.     Object    img = image.check();
  99.  
  100.     if (img != null && img instanceof Image) {
  101.         return ((Image) img).width;
  102.     }
  103.     return 20;
  104.     }
  105.  
  106.     public int height() {
  107.     if (bm != null) {
  108.         return bm.height;
  109.     }
  110.     Object    img = image.check();
  111.  
  112.     if (img != null && img instanceof Image) {
  113.         return ((Image) img).height;
  114.     }
  115.     return 20;
  116.     }
  117.  
  118.     public boolean isFetching() {
  119.     return fetching;
  120.     }
  121.  
  122.     public void setFetching() {
  123.     fetching = true;
  124.     }
  125.  
  126.     public synchronized void deleteObserver(Observer o) {
  127.     super.deleteObserver(o);
  128.     if ((url != null) && (countObservers() == 0)) {
  129.         ImageCache.cancelFetch(this);
  130.     }
  131.     }
  132.  
  133.     /** This routine is called by the ImageReader.  The getImage()
  134.     waits around for this method to complete. */
  135.     public void fetchImage() {
  136.     InputStream in = null;
  137.     try {
  138.         in = url.openStreamInteractively();
  139.         url.getContent(in, this);
  140.         setImage(win.createImage(bm));
  141.     } catch(Exception e) {
  142. //        e.printStackTrace();
  143.         setImage("Error " + e + " reading " + url.toExternalForm());
  144.         // We may have gotten a preliminary notification of the bitmap
  145.         // but now it is useless, so drop it immediately.
  146.         bm = null;
  147.     } finally {
  148.         if (in != null) {
  149.         in.close();
  150.         }
  151.     }
  152.     /* observers were notified in setImage, so anyone who
  153.        cared already got their hands on the bitmap */
  154.     bm = null;
  155.     }
  156.  
  157.     public synchronized void update(Observable o) {
  158.     bm = (DIBitmap) o;
  159.     notifyAll();
  160.     setChanged();
  161.     notifyObservers();
  162.     }
  163.  
  164.     public void addObserver(Observer o) {
  165.     super.addObserver(o);
  166.     }
  167.  
  168.     public String toString() {
  169.     return "ImageHandle " + url.toExternalForm();
  170.     }
  171. }
  172.  
  173. class ScaledImageHandle extends ImageHandle {
  174.     int        needWidth;
  175.     int        needHeight;
  176.     ImageHandle    rawIH;
  177.  
  178.     ScaledImageHandle(ImageHandle rawIH, int w, int h) {
  179.     super(rawIH.win, (URL) null);
  180.     this.rawIH = rawIH;
  181.     needWidth = w;
  182.     needHeight = h;
  183.     }
  184.  
  185.     public int width() {
  186.     if (needWidth > 0)    
  187.         return needWidth;
  188.     else
  189.         return rawIH.width();
  190.     }
  191.  
  192.     public int height() {
  193.     if (needHeight > 0)
  194.         return needHeight;
  195.     else
  196.         return rawIH.height();
  197.     }
  198.  
  199.     public boolean isFetching() {
  200.     return rawIH.isFetching();
  201.     }
  202.  
  203.     public void setFetching() {
  204.     rawIH.setFetching();
  205.     }
  206.  
  207.     public void fetchImage() {
  208.     rawIH.fetchImage();
  209.     return;
  210.     }
  211.  
  212.     // This methid is unsafe. It should be synchronized but it isn't
  213.     public Object getImage(Observer o, boolean waitForIt) {
  214.     Object img = image.check();
  215.     if (img != null) {
  216.         // It is ready
  217.         return img;
  218.     }
  219.  
  220.     if (o != null) {
  221.         addObserver(o);
  222.     }
  223.  
  224.     img = rawIH.getImage(this, waitForIt);
  225.     if (img != null) {
  226.         // The unscaled version is ready
  227.         update(rawIH);
  228.         return image.check();
  229.     } 
  230.     return null;
  231.     }
  232.  
  233.     public synchronized void update(Observable o) {
  234.     Object     rawImg = rawIH.image.check();
  235.  
  236.     if (rawImg != null) {
  237.         if (rawImg instanceof String) {
  238.         setImage(rawImg);
  239.         } else {
  240.         Image srcimg = (Image) rawImg;
  241.         if (srcimg.width == needWidth && srcimg.height == needHeight) {
  242.             setImage(srcimg);
  243.         } else {
  244.             DIBitmap rawbm = rawIH.bm;
  245.             if (rawbm == null) {
  246.             rawbm = srcimg.getDIBitmap();
  247.             }
  248.             if (rawbm != null && rawbm.raster != null) {
  249.             setImage(win.createImage(rawbm, needWidth,
  250.                          needHeight));
  251.             }
  252.         }
  253.         }
  254.     }
  255.     notifyObservers();
  256.     }
  257.     
  258.     //public synchronized void deleteObserver(Observer o) {
  259.     // experiment to eliminate a deadlock.
  260.     public void deleteObserver(Observer o) {
  261.     super.deleteObserver(o);
  262.     if (countObservers() == 0) {
  263.         rawIH.deleteObserver(this);
  264.     }
  265.     }
  266.  
  267.     public String toString() {
  268.     return "ScaledImageHandle " + needWidth + "x" + needHeight + " - " + rawIH;
  269.     }
  270. }
  271.